Usenet 1993 July/InfoMagic USENET CD-ROM July 1993.ISO/sources/misc/volume6/glib/part04

Text File | 1989-05-14 | 50.2 KB | 1,923 lines

Newsgroups: comp.sources.misc
From: [e-mail] (Brandon S. Allbery - comp.sources.misc)
Subject: v06i105: glib part 4 of 15
Reply-To: [e-mail] (Greg Lee )

Posting-number: Volume 6, Issue 105
Submitted-by: [e-mail] (Greg Lee )
Archive-name: glib/part04

#! /bin/sh
# This is a shell archive.  Remove anything before this line, then unpack
# it by saving it into a file and typing "sh file".  To overwrite existing
# files, type "sh file -c".  You can also feed this as standard input via
# unshar, or by typing "sh <file", e.g..  If this archive is complete, you
# will see the following message at the end:
#        "End of archive 4 (of 15)."
# Contents:  d10pat.mnu d10tim.mnu glib.man glibinit.dp5 list.c
# Wrapped by lee@uhccux on Sun May  7 00:40:11 1989
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
if test -f 'd10pat.mnu' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'d10pat.mnu'\"
else
echo shar: Extracting \"'d10pat.mnu'\" \(10002 characters\)
sed "s/^X//" >'d10pat.mnu' <<'END_OF_FILE'
X/* $Id: d10pat.mnu,v 1.6 89/05/06 17:13:14 lee Exp $
X * GLIB - a Generic LIBrarian and editor for synths
X *
X * D10 Patch Librarian
X *
X * Code started 19 JAN 89 --  Michael R. Kesti [e-mail]
X * modified by Greg Lee
X * $Log:    d10pat.mnu,v $
X * Revision 1.6  89/05/06  17:13:14  lee
X * rel. to comp.sources.misc
X *
X */
X
X#include "glib.h"
X#include "vis.h"
X
X#define D10PATSIZE 38
X#define PATBASEADDR 0x070000
X#define RESERVESIZE 20
X
Xchar *visnum(), *visonoff();
X
X
X/* This array contains arbitrary screen labels */
Xstruct labelinfo Ldpat[] = {
X#MENU
X
X
X                         Reverb Type     %
X                         Reverb Time     %
X                         Reverb Level    %
X
X                         Patch Level     %
X
X                         Key Mode        %
X                         Split Point     %
X
X
X                                   LOWER           UPPER
X                                   -----           -----
X                Tone Select         %%              %%
X                Key Shift           %               %
X                Fine Tune           %               %
X                Bender Range        %               %
X                Assign Mode         %               %
X                Reverb Switch       %               %
X                Tone Balance        %
X
X
X Press SPACE BAR to sound note %   at volume %   for duration %  on channel % .
X#END
X-1,-1,NULL
X};
X
Xstruct paraminfo  Pdpat[] =  {
X/*
XNAME        TYPE        POS    MAX    OFFSET    MASK    SHIFT    ADHOC
X */
X#O reverbtype    reverbtype    %%    8    16
X#O reverbtime    reverbtime    %%    7    17
X#O reverblevel    reverblevel    %%    7    18
X#O patchlevel    patchlevel    %%    100    20
X#O keymode    keymode        %%    2    0
X#O splitpoint    split        %%    61    1
X#O ltonegroup    tonegroup    %%    3    2
X#O ltonenum    tonenum        %%    63    3
X#O utonegroup    tonegroup    %%    3    4
X#O utonenum    tonenum        %%    63    5
X#O lkeyshift    keyshift    %%    48    6
X#O ukeyshift    keyshift    %%    48    7
X#O lfinetune    finetune    %%    100    8
X#O ufinetune    finetune    %%    100    9
X#O lbendrange    bendrange    %%    24    10
X#O ubendrange    bendrange    %%    24    11
X#O lassignmode    assignmode    %%    3    12
X#O uassignmode    assignmode    %%    3    13
X#O lreverbsw    onoff        %%    1    14
X#O ureverbsw    onoff        %%    1    15
X#O tonebal    tonebal        %%    100    19
X#O autopitch    num        %%    127    -60
X#O autovol    num        %%    127    -63
X#O autodur    num        %%    20    -5    *5
X#O autochan    num        %%    16    -1    *5
XNULL,NULL,-1,-1,-1,-1,visnum,0,0,0,0
X};
X
X/*
X * dpatnum
X *
X * Convert a voice number (0 to 127) to the string displayed in the
X * librarian (ie. 011 to 188).
X */
X
Xchar *
Xdpatnum(n)
X{
X    static char v[4];
X
X    if ( n < 0 || n > 188 )
X        return("???");
X
X    if(n < 64) {
X        v[0] = '0';
X    } else {
X        v[0] = '1';
X        n -= 64;
X    }
X    v[1] = n/8 + '1';
X    v[2] = n%8 + '1';
X    v[3] = '\0';
X    return(v);
X}
X
X/*
X * dnumpat
X *
X * Convert a display-style voice number (011 to 188) to internal
X * format (0 to 127).
X */
X
Xdnumpat(n)
Xint n;
X{
X    int ld, md, rd;
X
X    /* crack out the digits as octal codes */
X    ld = (n / 100); /* left digit */
X    n %= 100;
X    md = (n / 10) - 1; /* middle digit */
X    rd = (n % 10) - 1; /* right digit */
X
X    if(ld < 0 || ld > 1 || md < 0 || md > 7 || rd < 0 || rd > 7) {
X        return(-1);
X    } else {
X        return((ld * 64) + (md * 8) + rd); /* combine as octal */
X    }
X}
X
X/*
X * dpatdin
X *
X * Take library bank 'data' and stuff values in the P array, by using
X * the setval function.
X */
X
Xdpatdin(data)
Xchar *data;
X{
X    /* The first RESERVESIZE bytes are reserved (arbitrarily) for the voice name */
X#SETVAL
X}
X
X/*
X * dpatdout
X *
X * Take (possibly changed) parameters values out of the P array and
X * put them back into the library bank 'data'.
X */
X
Xdpatdout(data)
Xchar *data;
X{
X#GETVAL
X}
X
X/*
X * dpatsedit
X *
X * Send a single voice to the edit buffer of the D10.  This will be whatever
X * voice is currently selected.
X */
X
Xdpatsedit(data)
Xchar *data;
X{
X    int n;
X    int cksum;
X
X    sendmidi(0xf0);
X    sendmidi(0x41);
X    sendmidi(0x10);
X    sendmidi(0x16);
X    sendmidi(0x12);        /* DT1 - Data set 1 command */
X    sendmidi(0x03);        /* address msb */
X    cksum = 0x03;
X    sendmidi(0x04);
X    cksum += 0x04;
X    sendmidi(0x00);        /* address lsb */
X    cksum += 0x00;
X    for(n = 0; n < D10PATSIZE; n++) {
X        sendmidi(data[n + RESERVESIZE] & 0x7f);
X        cksum += data[n + RESERVESIZE] & 0x7f;
X    }
X    sendmidi((-cksum) & 0x7f);    /* checksum */
X    sendmidi(EOX);
X}
X
X/*
X * dpatnof
X *
X * Return a pointer to the voice name buried in library bank data.
X */
Xchar *
Xdpatnof(data)
Xchar *data;
X{
X    static char currbuff[17];
X    char *p;
X    int m;
X
X    p = currbuff;
X    for ( m = 0 ; m < 16 ; m++ )
X        *p++ = data[m + 41];
X    *p = '\0';
X    return(currbuff);
X}
X
X/*
X * dpatsnof
X *
X * Set the voice name buried in data to name.
X */
Xdpatsnof(data,name)
Xchar *data;
Xchar *name;
X{
X    char *p;
X    int m;
X
X    for ( p = name, m = 0 ; *p != '\0' && m < 16 ; p++, m++ )
X        data[m + 41] = *p;
X    for ( ; m < 16 ; m++ )
X        data[m + 41] = ' ';
X}
X
X/* dpatsone - send a single voice to the D10 */
Xdpatsone(iv, data)
Xint iv;
Xchar *data;
X{
X    int n;
X    int cksum;
X    long curadd;
X    int addbyte;
X
X    curadd = PATBASEADDR;
X
X    for(n = 0; n < iv; n++) {
X        curadd += D10PATSIZE;
X        if((curadd & 0x80) != 0) {
X            curadd &= 0x7fff7f;
X            curadd += 0x100;
X        }
X        if((curadd & 0x8000) != 0) {
X            curadd &= 0x7f7f7f;
X            curadd += 0x10000;
X        }
X    }
X
X    sendmidi(0xf0);
X    sendmidi(0x41);
X    sendmidi(0x10);
X    sendmidi(0x16);
X    sendmidi(0x12);        /* DT1 - Data set 1 command */
X    addbyte = ((curadd >> 16) & 0x7f);    /* address msb */
X    sendmidi(addbyte);
X    cksum = addbyte;
X    addbyte = ((curadd >> 8) & 0x7f);
X    sendmidi(addbyte);
X    cksum += addbyte;
X    addbyte = (curadd & 0x7f);        /* address lsb */
X    sendmidi(addbyte);
X    cksum += addbyte;
X    for(n = 0; n < D10PATSIZE; n++) {
X        sendmidi(data[n + RESERVESIZE] & 0x7f);
X        cksum += data[n + RESERVESIZE] & 0x7f;
X    }
X    sendmidi((-cksum) & 0x7f);    /* checksum */
X    sendmidi(EOX);
X
X    return(0);
X}
X
X/* dpatgbulk - Request and read a bulk dump from the D10 */
Xdpatgbulk(data)
Xchar *data;
X{
X    static    char Buff[BUFSIZ];
X    int n, v, b2, ret = 1;
X    long begin, toolong;
X    long curadd;
X    int addbyte;
X    int cksum;
X
X    sprintf(Buff,"\nA: ");
X    windstr(Buff);
X
X    curadd = PATBASEADDR;
X
X    for(v = 0; v < Nvoices; v++) {
X
X        flushmidi();
X
X        if(v == 64) {
X            sprintf(Buff,"\nB: ");
X            windstr(Buff);
X        }
X        if((((v > 63) ? (v - 64) : v) % 10) != 0) {
X            sprintf(Buff, ".");
X        } else {
X            sprintf(Buff,"%d", (((v > 63) ? (v - 64) : v) / 10));
X        }
X        windstr(Buff);
X
X    /* request the voice */
X        sendmidi(0xf0);
X        sendmidi(0x41);
X        sendmidi(0x10);
X        sendmidi(0x16);
X        sendmidi(0x11);        /* RQ1 - Data request 1 command */
X
X        addbyte = ((curadd >> 16) & 0x7f);    /* address msb */
X        sendmidi(addbyte);
X        cksum = addbyte;
X        addbyte = ((curadd >> 8) & 0x7f);
X        sendmidi(addbyte);
X        cksum += addbyte;
X        addbyte = (curadd & 0x7f);        /* address lsb */
X        sendmidi(addbyte);
X        cksum += addbyte;
X
X        sendmidi(0x00);        /* length msb */
X        cksum += 0x00;
X        sendmidi(0x00);
X        cksum += 0x00;
X        sendmidi(D10PATSIZE);    /* length lsb */
X        cksum += D10PATSIZE;
X
X        sendmidi((-cksum) & 0x7f);    /* checksum */
X        sendmidi(EOX);
X
X    /* set up timeout */
X        begin = milliclock();
X        toolong = begin + (1000 * TIMEOUT);
X
X    /* read header */
X        for(n = 0; n < 8; ) {
X            if ( STATMIDI ) {
X                b2 = (getmidi() & 0xff);
X                /* burn active sensing and timing clock */
X                if((b2 != 0xfe) && (b2 != 0xf8))
X                    n++;
X            } else {
X                if ( milliclock() > toolong ) {
X                    Reason = "Timeout waiting for header";
X                    goto getout;
X                }
X            }
X        }
X
X    /* read data */
X        for(n = 0; n < D10PATSIZE; ) {
X            if ( STATMIDI ) {
X                b2 = (getmidi() & 0xff);
X                /* burn active sensing and timing clock */
X                if((b2 != 0xfe) && (b2 != 0xf8)) {
X                    VOICEBYTE(data,v,n + RESERVESIZE) = b2;
X                    n++;
X                }
X            } else {
X                if ( milliclock() > toolong ) {
X                    Reason = "Timeout reading data";
X                    goto timeout;
X                }
X            }
X        }
X
X    timeout:
X        if ( n != D10PATSIZE ) {
X            Reason = "Timeout reading data!";
X            goto getout;
X        }
X
X    /* read checksum */
X        for(n = 0; n < 1; ) {
X            if ( STATMIDI ) {
X                b2 = (getmidi() & 0xff);
X                /* burn active sensing and timing clock */
X                if((b2 != 0xfe) && (b2 != 0xf8))
X                    n++;
X            } else {
X                if ( milliclock() > toolong ) {
X                    Reason = "Timeout reading checksum";
X                    goto getout;
X                }
X            }
X        }
X
X    /* read EOX */
X        for(n = 0; n < 1; ) {
X            if ( STATMIDI ) {
X                b2 = (getmidi() & 0xff);
X                /* burn active sensing and timing clock */
X                if((b2 != 0xfe) && (b2 != 0xf8))
X                    if ( b2 != EOX ) {
X                        sprintf(Buff,"EOX not received (%X)\n", b2);
X                        Reason = Buff;
X                        goto getout;
X                    }
X                    n++;
X            } else {
X                if ( milliclock() > toolong ) {
X                    Reason = "Timeout reading EOX";
X                    goto getout;
X                }
X            }
X        }
X
X        curadd += D10PATSIZE;
X
X        if((curadd & 0x80) != 0) {
X            curadd &= 0x7fff7f;
X            curadd += 0x100;
X        }
X        if((curadd & 0x8000) != 0) {
X            curadd &= 0x7f7f7f;
X            curadd += 0x10000;
X        }
X
X    } /* go back for another voice */
X
X    Reason = "";
X    ret = 0;    /* all's well */
X
Xgetout:
X    return(ret);
X}
X
X/* dpatsbulk - send a bulk dump to the D10 */
Xdpatsbulk(data)
Xchar *data;
X{
X    static char Buff[BUFSIZ];
X    int v, n;
X    int cksum;
X    long curadd;
X    int addbyte, databyte;
X    int curoff;
X
X    curadd = PATBASEADDR;
X    curoff = 0;
X    sprintf(Buff,"\nA: ");
X    windstr(Buff);
X
X    for(v = 0; v <Nvoices ; v++) {
X        if(v == 64) {
X            sprintf(Buff,"\nB: ");
X            windstr(Buff);
X        }
X        if((((v > 63) ? (v - 64) : v) % 10) != 0) {
X            sprintf(Buff, ".");
X        } else {
X            sprintf(Buff,"%d", (((v > 63) ? (v - 64) : v) / 10));
X        }
X
X        windstr(Buff);
X        sendmidi(0xf0);
X        sendmidi(0x41);
X        sendmidi(0x10);
X        sendmidi(0x16);
X        sendmidi(0x12);        /* DT1 - Data set 1 command */
X        addbyte = ((curadd >> 16) & 0x7f);    /* address msb */
X        sendmidi(addbyte);
X        cksum = addbyte;
X        addbyte = ((curadd >> 8) & 0x7f);
X        sendmidi(addbyte);
X        cksum += addbyte;
X        addbyte = (curadd & 0x7f);        /* address lsb */
X        sendmidi(addbyte);
X        cksum += addbyte;
X
X        for(n = 0; n < D10PATSIZE; n++) {
X            databyte = data[curoff + n + RESERVESIZE] & 0x7f;
X            sendmidi(databyte);
X            cksum += databyte;
X        }
X        sendmidi((-cksum) & 0x7f);    /* checksum */
X        sendmidi(EOX);
X
X        curadd += D10PATSIZE;
X        if((curadd & 0x80) != 0) {
X            curadd &= 0x7fff7f;
X            curadd += 0x100;
X        }
X        if((curadd & 0x8000) != 0) {
X            curadd &= 0x7f7f7f;
X            curadd += 0x10000;
X        }
X        curoff += (D10PATSIZE + RESERVESIZE);
X    }
X    return(0);
X}
X
X/* end */
END_OF_FILE
if test 10002 -ne `wc -c <'d10pat.mnu'`; then
    echo shar: \"'d10pat.mnu'\" unpacked with wrong size!
fi
# end of 'd10pat.mnu'
fi
if test -f 'd10tim.mnu' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'d10tim.mnu'\"
else
echo shar: Extracting \"'d10tim.mnu'\" \(9098 characters\)
sed "s/^X//" >'d10tim.mnu' <<'END_OF_FILE'
X/* $Id: d10tim.mnu,v 1.6 89/05/06 17:13:16 lee Exp $
X * GLIB - a Generic LIBrarian and editor for synths
X *
X * D10 Timbre Librarian
X *
X * Code started 23 JAN 89 --  Michael R. Kesti [e-mail]
X * modified by Greg Lee
X * $Log:    d10tim.mnu,v $
X * Revision 1.6  89/05/06  17:13:16  lee
X * rel. to comp.sources.misc
X *
X */
X
X#include "glib.h"
X#include "vis.h"
X
X#define D10TIMSIZE 8
X#define TIMBASEADDR 0x050000
X#define RESERVESIZE 20
X
Xchar *visnum(), *visonoff();
X
X/* This array contains arbitrary screen labels */
Xstruct labelinfo Ldtim[] = {
X#MENU
X
X
X
X
X
X
X
X
X                         Tone Select         %%
X                         Key Shift           %
X                         Fine Tune           %
X                         Bender Range        %
X                         Assign Mode         %
X                         Reverb Switch       %
X
X
X
X
X
X
X
X
X
X Press SPACE BAR to sound note %   at volume %   for duration %  on channel % .
X#END
X-1,-1,NULL
X};
X
Xstruct paraminfo  Pdtim[] =  {
X/*
XNAME        TYPE        POS    MAX    OFFSET    MASK    SHIFT    ADHOC
X */
X#O tonegroup    tonegroup    %%    3    0
X#O tonenum    tonenum        %%    63    1
X#O keyshift    keyshift    %%    48    2
X#O finetune    finetune    %%    100    3
X#O bendrange    bendrange    %%    24    4
X#O assignmode    assignmode    %%    3    5
X#O reverbsw    onoff        %%    1    6
X#O autopitch    num        %%    127    -60
X#O autovol    num        %%    127    -63
X#O autodur    num        %%    20    -5    *5
X#O autochan    num        %%    16    -1    *5
XNULL,NULL,-1,-1,-1,-1,visnum,0,0,0,0
X};
X
X/*
X * dtimnum
X *
X * Convert a voice number (0 to 127) to the string displayed in the
X * librarian (ie. 011 to 188).
X */
X
Xchar *
Xdtimnum(n)
X{
X    static char v[4];
X
X    if ( n < 0 || n > 188 )
X        return("???");
X
X    if(n < 64) {
X        v[0] = '0';
X    } else {
X        v[0] = '1';
X        n -= 64;
X    }
X    v[1] = n/8 + '1';
X    v[2] = n%8 + '1';
X    v[3] = '\0';
X    return(v);
X}
X
X/*
X * dnumtim
X *
X * Convert a display-style voice number (011 to 188) to internal
X * format (0 to 127).
X */
X
Xdnumtim(n)
Xint n;
X{
X    int ld, md, rd;
X
X    /* crack out the digits as octal codes */
X    ld = (n / 100); /* left digit */
X    n %= 100;
X    md = (n / 10) - 1; /* middle digit */
X    rd = (n % 10) - 1; /* right digit */
X
X    if(ld < 0 || ld > 1 || md < 0 || md > 7 || rd < 0 || rd > 7) {
X        return(-1);
X    } else {
X        return((ld * 64) + (md * 8) + rd); /* combine as octal */
X    }
X}
X
X/*
X * dtimdin
X *
X * Take library bank 'data' and stuff values in the P array, by using
X * the setval function.
X */
X
Xdtimdin(data)
Xchar *data;
X{
X    /* The first RESERVESIZE bytes are reserved (arbitrarily) for the voice name */
X#SETVAL
X}
X
X/*
X * dtimdout
X *
X * Take (possibly changed) parameters values out of the P array and
X * put them back into the library bank 'data'.
X */
X
Xdtimdout(data)
Xchar *data;
X{
X#GETVAL
X}
X
X/*
X * dtimsedit
X *
X * Send a single voice to the edit buffer of the D10.  This will be whatever
X * voice is currently selected.
X */
X
Xdtimsedit(data)
Xchar *data;
X{
X    int n;
X    int cksum;
X
X    sendmidi(0xf0);
X    sendmidi(0x41);
X    sendmidi(0x10);
X    sendmidi(0x16);
X    sendmidi(0x12);        /* DT1 - Data set 1 command */
X    sendmidi(0x03);        /* address msb */
X    cksum = 0x03;
X    sendmidi(0x00);
X    cksum += 0x00;
X    sendmidi(0x00);        /* address lsb */
X    cksum += 0x00;
X    for(n = 0; n < D10TIMSIZE; n++) {
X        sendmidi(data[n + RESERVESIZE] & 0x7f);
X        cksum += data[n + RESERVESIZE] & 0x7f;
X    }
X    sendmidi((-cksum) & 0x7f);    /* checksum */
X    sendmidi(EOX);
X}
X
X/*
X * dtimnof
X *
X * Return a pointer to the voice name buried in library bank data.
X */
Xchar *
Xdtimnof(data)
Xchar *data;
X{
X
X    static char buf[4];
X    int n;
X
X    for(n = 0; n < D10TIMSIZE; n++)
X        if ( data[n + RESERVESIZE] != 0 ) break;
X    if ( n != D10TIMSIZE ) {
X        strcpy(buf, vistonegroup(data[RESERVESIZE + 0]));
X        strcat(buf, vistonenum(data[RESERVESIZE + 1]));
X    } else
X        strcpy(buf, "   ");
X
X    return(buf);
X}
X
X/*
X * dtimsnof
X *
X * Set the voice name buried in data to name.
X */
Xdtimsnof(data,name)
Xchar *data;
Xchar *name;
X{
X}
X
X/* dtimsone - send a single voice to the D10 */
Xdtimsone(iv, data)
Xint iv;
Xchar *data;
X{
X    int n;
X    int cksum;
X    long curadd;
X    int addbyte;
X
X    curadd = TIMBASEADDR;
X
X    for(n = 0; n < iv; n++) {
X        curadd += D10TIMSIZE;
X        if((curadd & 0x80) != 0) {
X            curadd &= 0x7fff7f;
X            curadd += 0x100;
X        }
X        if((curadd & 0x8000) != 0) {
X            curadd &= 0x7f7f7f;
X            curadd += 0x10000;
X        }
X    }
X
X    sendmidi(0xf0);
X    sendmidi(0x41);
X    sendmidi(0x10);
X    sendmidi(0x16);
X    sendmidi(0x12);        /* DT1 - Data set 1 command */
X    addbyte = ((curadd >> 16) & 0x7f);    /* address msb */
X    sendmidi(addbyte);
X    cksum = addbyte;
X    addbyte = ((curadd >> 8) & 0x7f);
X    sendmidi(addbyte);
X    cksum += addbyte;
X    addbyte = (curadd & 0x7f);        /* address lsb */
X    sendmidi(addbyte);
X    cksum += addbyte;
X    for(n = 0; n < D10TIMSIZE; n++) {
X        sendmidi(data[n + RESERVESIZE] & 0x7f);
X        cksum += data[n + RESERVESIZE] & 0x7f;
X    }
X    sendmidi((-cksum) & 0x7f);    /* checksum */
X    sendmidi(EOX);
X
X    return(0);
X}
X
X/* dtimgbulk - Request and read a bulk dump from the D10 */
Xdtimgbulk(data)
Xchar *data;
X{
X    static    char Buff[BUFSIZ];
X    int n, v, b2, ret = 1;
X    long begin, toolong;
X    long curadd;
X    int addbyte;
X    int cksum;
X
X    sprintf(Buff,"\nA: ");
X    windstr(Buff);
X
X    curadd = TIMBASEADDR;
X
X    for(v = 0; v < Nvoices; v++) {
X
X        flushmidi();
X
X        if(v == 64) {
X            sprintf(Buff,"\nB: ");
X            windstr(Buff);
X        }
X        if((((v > 63) ? (v - 64) : v) % 10) != 0) {
X            sprintf(Buff, ".");
X        } else {
X            sprintf(Buff,"%d", (((v > 63) ? (v - 64) : v) / 10));
X        }
X        windstr(Buff);
X
X    /* request the voice */
X        sendmidi(0xf0);
X        sendmidi(0x41);
X        sendmidi(0x10);
X        sendmidi(0x16);
X        sendmidi(0x11);        /* RQ1 - Data request 1 command */
X
X        addbyte = ((curadd >> 16) & 0x7f);    /* address msb */
X        sendmidi(addbyte);
X        cksum = addbyte;
X        addbyte = ((curadd >> 8) & 0x7f);
X        sendmidi(addbyte);
X        cksum += addbyte;
X        addbyte = (curadd & 0x7f);        /* address lsb */
X        sendmidi(addbyte);
X        cksum += addbyte;
X
X        sendmidi(0x00);        /* length msb */
X        cksum += 0x00;
X        sendmidi(0x00);
X        cksum += 0x00;
X        sendmidi(D10TIMSIZE);    /* length lsb */
X        cksum += D10TIMSIZE;
X
X        sendmidi((-cksum) & 0x7f);    /* checksum */
X        sendmidi(EOX);
X
X    /* set up timeout */
X        begin = milliclock();
X        toolong = begin + (1000 * TIMEOUT);
X
X    /* read header */
X        for(n = 0; n < 8; ) {
X            if ( STATMIDI ) {
X                b2 = (getmidi() & 0xff);
X                /* burn active sensing and timing clock */
X                if((b2 != 0xfe) && (b2 != 0xf8))
X                    n++;
X            } else {
X                if ( milliclock() > toolong ) {
X                    Reason = "Timeout waiting for header";
X                    goto getout;
X                }
X            }
X        }
X
X    /* read data */
X        for(n = 0; n < D10TIMSIZE; ) {
X            if ( STATMIDI ) {
X                b2 = (getmidi() & 0xff);
X                /* burn active sensing and timing clock */
X                if((b2 != 0xfe) && (b2 != 0xf8)) {
X                    VOICEBYTE(data,v,n + RESERVESIZE) = b2;
X                    n++;
X                }
X            } else {
X                if ( milliclock() > toolong ) {
X                    Reason = "Timeout reading data";
X                    goto timeout;
X                }
X            }
X        }
X
X    timeout:
X        if ( n != D10TIMSIZE ) {
X            Reason = "Timeout reading data!";
X            goto getout;
X        }
X
X    /* read checksum */
X        for(n = 0; n < 1; ) {
X            if ( STATMIDI ) {
X                b2 = (getmidi() & 0xff);
X                /* burn active sensing and timing clock */
X                if((b2 != 0xfe) && (b2 != 0xf8))
X                    n++;
X            } else {
X                if ( milliclock() > toolong ) {
X                    Reason = "Timeout reading checksum";
X                    goto getout;
X                }
X            }
X        }
X
X    /* read EOX */
X        for(n = 0; n < 1; ) {
X            if ( STATMIDI ) {
X                b2 = (getmidi() & 0xff);
X                /* burn active sensing and timing clock */
X                if((b2 != 0xfe) && (b2 != 0xf8))
X                    if ( b2 != EOX ) {
X                        sprintf(Buff,"EOX not received (%X)\n", b2);
X                        Reason = Buff;
X                        goto getout;
X                    }
X                    n++;
X            } else {
X                if ( milliclock() > toolong ) {
X                    Reason = "Timeout reading EOX";
X                    goto getout;
X                }
X            }
X        }
X        curadd += D10TIMSIZE;
X        if((curadd & 0x80) != 0) {
X            curadd &= 0x7fff7f;
X            curadd += 0x100;
X        }
X        if((curadd & 0x8000) != 0) {
X            curadd &= 0x7f7f7f;
X            curadd += 0x10000;
X        }
X
X
X    } /* go back for another voice */
X
X    Reason = "";
X    ret = 0;    /* all's well */
X
Xgetout:
X    return(ret);
X}
X
X/* dtimsbulk - send a bulk dump to the D10 */
Xdtimsbulk(data)
Xchar *data;
X{
X    static char Buff[BUFSIZ];
X    int v, n;
X    int cksum;
X    long curadd;
X    int addbyte, databyte;
X    int curoff;
X
X    curadd = TIMBASEADDR;
X    curoff = 0;
X    sprintf(Buff,"\nA: ");
X    windstr(Buff);
X
X    for(v = 0; v <Nvoices ; v++) {
X        if(v == 64) {
X            sprintf(Buff,"\nB: ");
X            windstr(Buff);
X        }
X        if((((v > 63) ? (v - 64) : v) % 10) != 0) {
X            sprintf(Buff, ".");
X        } else {
X            sprintf(Buff,"%d", (((v > 63) ? (v - 64) : v) / 10));
X        }
X
X        windstr(Buff);
X        sendmidi(0xf0);
X        sendmidi(0x41);
X        sendmidi(0x10);
X        sendmidi(0x16);
X        sendmidi(0x12);        /* DT1 - Data set 1 command */
X        addbyte = ((curadd >> 16) & 0x7f);    /* address msb */
X        sendmidi(addbyte);
X        cksum = addbyte;
X        addbyte = ((curadd >> 8) & 0x7f);
X        sendmidi(addbyte);
X        cksum += addbyte;
X        addbyte = (curadd & 0x7f);        /* address lsb */
X        sendmidi(addbyte);
X        cksum += addbyte;
X
X        for(n = 0; n < D10TIMSIZE; n++) {
X            databyte = data[curoff + n + RESERVESIZE] & 0x7f;
X            sendmidi(databyte);
X            cksum += databyte;
X        }
X        sendmidi((-cksum) & 0x7f);    /* checksum */
X        sendmidi(EOX);
X
X        curadd += D10TIMSIZE;
X        if((curadd & 0x80) != 0) {
X            curadd &= 0x7fff7f;
X            curadd += 0x100;
X        }
X        if((curadd & 0x8000) != 0) {
X            curadd &= 0x7f7f7f;
X            curadd += 0x10000;
X        }
X        curoff += (D10TIMSIZE + RESERVESIZE);
X    }
X    return(0);
X}
X
X/* end */
END_OF_FILE
if test 9098 -ne `wc -c <'d10tim.mnu'`; then
    echo shar: \"'d10tim.mnu'\" unpacked with wrong size!
fi
# end of 'd10tim.mnu'
fi
if test -f 'glib.man' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'glib.man'\"
else
echo shar: Extracting \"'glib.man'\" \(8556 characters\)
sed "s/^X//" >'glib.man' <<'END_OF_FILE'
X
X                                                           GLIB(1) LOCAL
X
X
X
XNAME
X     glib - patch editor and librarian for synthesizers
X
XSYNOPSIS
X     glib
X
XDESCRIPTION
X     Glib (one syllable) is a text-screen-oriented librarian and patch
X     editor for electronic synthesizers.  It is structured in an attempt
X     to make it easy to add support for new synthesizers.  Glib presents
X     three types of menu screens:  synthesizer selection, patch
X     librarian, and patch editor.  However, depending on choices made
X     when glib was compiled, there may be no synthesizer selection menu,
X     or it may be used to select different sub-parts of a single synth,
X     rather than among different synths.  From the outermost selection
X     menu you descend to the librarian.  If there is no synth selection
X     menu, you see the librarian screen immediately after invoking glib.
X
X     The librarian part of the program manipulates 1 synth bank of
X     voices (which can be uploaded to or downloaded from the synth), and
X     3 banks of library voices (which can be read/written to disk).
X     When you exit the librarian and select a different synth, the
X     contents of the library banks and other settings (e.g. midi
X     channel) for each are retained.
X
X     From the librarian screen you can descend to the patch editor
X     screen to change or create an individual patch for a given
X     synthesizer.  Details about using the librarian and the patch
X     editor are given below.
X
X     The glib distribution includes support files for various PCs --
X     IBM, Atari ST, Macintosh, Amiga.  And you can run glib on Unix (it
X     uses curses), although obviously most Unix machines don't have midi
X     I/O.  Trying it out on Unix will give you a feel for what the
X     program does, so you can decide whether or not it's worth the
X     trouble to port it to your midi-capable PC.  Or your could edit
X     patch files on a Unix system and download them to a PC.
X
X     The current version of glib, version 1.6, supports the
X     synthesizers:  DX100, TX81, DEP5, DW8000, Roland D-10, Kawaii K1
X     K5, DX7, and Casio CZ1.
X
XUsing glib - Moving around
X     Both the librarian and editor parts of glib make use of arrow keys,
X     <CTRL/B> <CTRL/N> <CTRL/P> <CTRL/F> or h j k l to move the cursor
X     around.  (The arrow keys may not work on non-Unix versions,
X     though.) <CTRL/L> redraws the screen.  These keys are #defined in
X     glib.h, so you can change them if you want.  To quit from any mode,
X     use q. In the librarian screen, ? gives a command summary.  Esc or
X     grave accent key sends an all-notes-off (though the support for
X     arrow keys may interfere with this use of esc ).
X
X
XUsing glib - The librarian
X     The screen shows the synth bank on the left, and the current (1 of
X     3) library bank on the right.  A * identifies the `current' voice,
X     and you use the arrow keys to move it around.  As soon as you move
X     to a different voice, it is sent to the `edit buffer' of the synth,
X     so it is very easy to roam around and see what each voice sounds
X     like.  Commands:
X
X     b -  Cycle through the (3) library banks, displayed on the right
X          side of the screen.
X
X     c -  Set the midi channel for sending/receiving voices.
X
X     d -  Download from the (real) synthesizer, replacing the current
X          contents of the synth bank.
X
X     D -  Download from a file, replacing the current contents of the
X          synth bank.  Same as above, except input comes from file
X          instead of the synth.  (Implemented only for Unix version.)
X
X     e -  Edit the current voice (see editor description below).
X
X     f -  List the files on the disk.
X
X     p -  Put the yank buffer, replacing the contents of the current
X          voice.
X
X     q -  Quit, going back to `choose a synth'.
X
X     r -  Read a bank of voices from a file, replacing entirely the
X          current library bank.
X
X     R -  Read a bank of voices from a text file (created with the W
X          command).
X
X     s -  Swap the current voice with the yank buffer.  2 swaps is a
X          no-op.
X
X     t -  Transfer all voices, either from the current library bank to
X          the synth bank, or vice versa.
X
X     u -  Upload the current contents of the synth bank to the synth.
X          You are given a choice of sending the entire bank or just the
X          current voice.
X
X     U -  Upload the current contents of the synth bank to a file.  Same
X          as above, except output goes to file instead of the synth.
X          (Implemented only for Unix version.)
X
X     w -  Write the current library bank to a file.
X
X     W -  Write the current library bank to an editable text file.  This
X          is slow, and is meant for use in some special circumstance -
X          for instance if you changed the binary format of files, you
X          might want to convert your old patches.
X
X     y -  Yank the current voice into the yank buffer, shown in the
X          middle of the screen.
X
X
XUsing glib - The editor
X     In the editor part, arrow keys move the cursor among the parameter
X     values.  The cursor will only land on parameter values.  Once on a
X     parameter value, the following keys will affect it:
X
X     K -  increase value by 1
X
X     J -  decrease value by 1
X
X     I -  increase value by 4
X
X     M -  decrease value by 4
X
X     < -  decrease value to its minimum
X
X     > -  increase value to its maximum
X
X     S -  assign same value as last assigned
X
X     These keys are defined in glib.h, and should be changed to suit
X     your own tastes.  I'm not thrilled with these choices, myself, but
X     I had to use something, and at least the hand may stay in one
X     place.
X
X     To change the name of a voice, use `N'.
X
X     The `auto-note' is played whenever you press the space bar.  This
X     is a convenient way of playing a note as soon as you make a change
X     (ie.  you can do everything from the computer keyboard).  You can
X     change the auto-note parameters (pitch, duration, volume, channel)
X     the same way as all the other parameters.
X
XSynthesizers
X     Here is a list of the sample patch files for each synthesizer in
X     the 1.6 release of glib, together with occasional notes on the
X     current implementation.
X
X     DX100
X          Sample patches:  fact1.dx1
X
X     TX81 Sample patches:  fact1.t8p fact1.tx8
X
X     DEP5 Sample patches:  fact1.dp5
X
X     DW8000
X          Sample patches:  fact1.dw8
X
X     Roland D-10
X          Sample patches:  d10fact.pat d10fact.rsu d10fact.tim
X          d10fact.ton d10fact.tra d10fact.urp
X
X     Kawaii K1
X          Sample patches:  k1fact.mlt k1fact.sgl
X
X          Voices are not sent to the K1's edit buffer.
X          For Kawai K1 multi patches, names of single patches referred
X          to are displayed when they can be found in the synth voice
X          bank of the single patches module.  The names are updated
X          whenever a new bank of voices is transferred into this bank.
X
X     Kawaii K5
X          Sample patches:  card1.k5m card1.k5s
X          Editing of voices is not implemented.
X
X     DX7  Sample patches:  n001.dx7 rom1.d7s
X
X          Some of the parameters on the DX7s editing screen are
X          `multiplexed'.  Move the cursor to the `Modulation Wheel'
X          legend, then `increment' and `decrement' this field:  the
X          fields below it will cycle through the `Modulation Wheel',
X          `Aftertouch', `Breath Control', `Foot Control', and `MIDI
X          Control' parameters.
X
X     Casio CZ1
X          Sample patches:  bank1.cz1
X
X          The performance parameters given on the lower part of the
X          editing screen, Glib, Portamento, etc., are just there pro
X          forma.  In the current version, setting them doesn't
X          accomplish anything.
X
XAUTHORS
X
X     original version for dx100, tx81z, dep5:  Tim Thompson,
X          ...twitch!glimmer!tjt
X
X     Macintosh and dw1000 support:  Steve Falco.
X
X     d10 support:  Michael Kesti, [e-mail]
X
X     Amiga and k5 support:  Alan Bland, [e-mail]
X          or att!druwy!mab
X
X     K1 support and menu mods:  Greg Lee, [e-mail]
X
X     DX7 support:  Scott Snyder, [e-mail],
X          [e-mail] (addresses valid until mid-June)
X
X     CZ1 support:  Mark R. Rinfret, [e-mail],
X          ...!rayssd!galaxia!amanpt1!mrr
X
X     arp file requester, Amiga version:  Dave Weiler
X
X     Some of the code was originally written by Steve Frysinger
X     (moss!spf), John Helton, and James Gosling.
END_OF_FILE
if test 8556 -ne `wc -c <'glib.man'`; then
    echo shar: \"'glib.man'\" unpacked with wrong size!
fi
# end of 'glib.man'
fi
if test -f 'glibinit.dp5' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'glibinit.dp5'\"
else
echo shar: Extracting \"'glibinit.dp5'\" \(9806 characters\)
sed "s/^X//" >'glibinit.dp5' <<'END_OF_FILE'
X#-This-is-the-Chdepth-data
X0,0  7,1  14,2  18,3  21,4
X24,5  27,6  29,7  31,8  33,9
X35,10 37,11 39,12 40,13 42,14
X44,15 45,16 47,17 48,18 49,19
X51,20 52,21 53,22 54,23 56,24
X57,25 58,26 59,27 60,28 61,29
X62,30 63,31 64,32 65,33 66,34
X67,35 68,36 69,37 70,38 71,39
X72,40 74,42 75,43 76,45 77,46
X78,47 79,48 80,49 81,51 82,52
X83,53 84,54 85,56 86,57 87,58
X88,60 89,61 90,62 91,64 92,65
X93,67 94,68 95,70 96,71 97,73
X98,74 99,76 100,77 101,79 102,80
X103,82 104,83 105,85 106,87 107,88
X108,90 109,92 110,93 111,95 112,97
X113,98 114,100 115,102 116,104 117,105
X118,107 119,109 120,111 121,113 122,115
X123,117 124,118 125,120 126,122 127,124
X128,126 129,128 130,130 131,132 132,134
X133,136 134,138 135,140 136,142 137,145
X138,147 139,149 140,151 141,153 142,155
X143,157 144,160 145,162 146,164 147,166
X148,169 149,171 150,173 151,176 152,178
X153,180 154,183 155,185 156,187 157,190
X158,192 159,195 160,197 161,200 162,202
X163,204 164,207 165,210 166,212 167,215
X168,217 169,220 170,222 171,225 172,228
X173,230 174,233 175,236 176,238 177,241
X178,244 179,247 180,249 181,252 182,255
X183,258 184,261 185,263 186,266 187,269
X188,272 189,275 190,278 191,281 192,284
X193,287 194,290 195,293 196,296 197,299
X198,302 199,305 200,308 201,311 202,314
X203,317 204,320 205,323 206,327 207,330
X208,333 209,336 210,339 211,343 212,346
X213,349 214,352 215,356 216,359 217,362
X218,366 219,369 220,372 221,376 222,379
X223,383 224,386 225,389 226,393 227,396
X228,400 229,403 230,407 231,411 232,414
X233,418 234,421 235,425 236,428 237,432
X238,436 239,439 240,443 241,447 242,451
X243,454 244,458 245,462 246,466 247,469
X248,473 249,477 250,481 251,485 252,489
X253,492 254,496 255,500
X#-This-is-the-freq-data
X30 31 32 33 34 35 36 37 38 39
X40 41 42 43 44 45 46 47 48 49
X51 53 55 57 59 61 63 65 67 69
X71 73 75 77 79 81 83 86 89 92
X95 98 101 104 107 110 113 116 119 123
X127 131 135 139 143 147 151 155 160 165
X170 175 180 185 191 197 203 209 215 221
X228 235 242 249 256 264 272 280 288 297
X306 315 324 334 344 354 364 375 386 397
X409 421 433 446 459 473 487 501 516 531
X547 563 580 597 615 633 652 671 691 711
X732 754 776 799 823 847 872 898 824 851
X979 1010 1040 1070 1100 1130 1160 1200
X#-This-is-the-Hf-data
X0,100 1,99 4,98 6,97 9,96
X12,95 14,94 17,93 20,92 22,91
X25,90 28,89 30,88 33,87 36,86
X39,85 41,84 44,83 47,82 49,81
X52,80 55,79 57,78 60,77 63,76
X66,75 68,74 71,73 74,72 76,71
X79,70 82,69 84,68 87,67 90,66
X92,65 95,64 98,63 101,62 103,61
X106,60 109,59 111,58 114,57 117,56
X119,55 122,54 125,53 128,52 130,51
X133,50 136,49 138,48 141,47 144,46
X146,45 149,44 152,43 154,42 157,41
X160,40 163,39 165,38 168,37 171,36
X173,35 176,34 179,33 181,32 184,31
X187,30 189,29 192,28 195,27 198,26
X200,25 203,24 206,23 208,22 211,21
X214,20 216,19 219,18 222,17 225,16
X227,15 230,14 233,13 235,12 238,11
X241,10 243,9 246,8 249,7 251,6
X254,5
X#-This-is-the-Gate-time
X10 11 11 12 13 14 14 15 16 17
X18 19 20 21 22 23 24 25 26 28
X29 30 31 33 34 35 36 38 39 41
X42 43 45 46 48 50 51 53 54 56
X58 59 61 63 65 67 68 70 72 74
X76 78 80 82 84 86 88 90 92 95
X97 99 101 103 106 108 110 113 115 117
X120 122 125 127 130 132 135 138 140 143
X146 148 151 154 157 159 162 165 168 171
X174 177 180 183 186 189 192 195 198 201
X205 208 211 214 217 221 224 227 231 234
X238 241 245 248 252 255 259 262 266 270
X273 277 281 285 288 292 296 300 304 308
X312 316 319 323 328 332 336 340 344 348
X352 356 361 365 369 373 378 382 387 391
X395 400 404 409 413 418 422 427 432 436
X441 446 450 455 460 465 470 474 479 484
X489 494 499 504 509 514 519 524 530 535
X540 545 550 556 561 566 571 577 582 588
X593 598 604 609 615 621 626 632 637 643
X649 654 660 666 672 677 683 689 695 701
X707 713 719 725 731 737 743 749 755 761
X767 774 780 786 792 799 805 811 818 824
X831 837 843 850 856 863 870 876 883 889
X896 903 910 916 923 930 937 944 950 957
X964 971 978 985 992 999
X#-This-is-the-Chrate
X0,3  21,4  32,5  41,6  48,7
X54,8  60,9 65,10 70,11 74,12
X79,13 83,14 87,15 90,16 94,17
X98,18 101,19 104,20 107,21 110,22
X113,23 116,24 119,25 122,26 125,27
X130,29 132,30 135,31 137,32 140,33
X142,34 145,35 147,36 149,37 152,38
X154,39 156,40 158,41 160,42 162,43
X164,44 166,45 168,46 170,47 172,48
X174,49 176,50 178,51 180,52 182,53
X184,54 186,55 188,56 190,57 191,58
X193,59 195,60 196,61 198,62 200,63
X202,64 203,65 205,66 207,67 208,68
X210,69 211,70 213,71 215,72 216,73
X218,74 219,75 221,76 222,77 224,78
X226,79 227,80 229,81 230,82 232,83
X233,84 234,85 236,86 237,87 239,88
X240,89 242,90 243,91 244,92 246,93
X247,94 249,95 250,96 251,97 253,98
X254,99 155,100
X#-This-is-Nlrevtime
X0,-9    3,-8    7,-7    11,-6   15,-5
X19,-4   23,-3   27,-2   31,-1   35,0
X38,1    42,2    46,3    50,4    54,5
X58,6    62,7    66,8    70,9    74,10
X78,11   82,12   86,13   90,14   94,15
X97,16   99,17   101,18  102,19  103,20
X104,21  105,22  106,23  107,24  108,26
X109,27  110,28  111,30  112,31  113,33
X114,35  115,36  116,38  117,40  118,42
X119,44  120,46  121,48  122,51  123,53
X124,55  125,58  126,60  127,63  128,66
X129,69  130,71  131,74  132,77  133,80
X134,83  135,87  136,90  137,93  138,97
X139,100 142,110 145,120 147,130 150,140
X152,150 154,160 156,170 158,180 160,190
X162,200 164,210 166,220 168,230 170,240
X172,250 173,260 175,270 177,280 180,300
X181,310 183,320 184,330 186,340 187,350
X189,360 190,370 191,380 193,390 194,400
X196,410 197,420 198,430 199,440 201,450
X202,460 203,470 204,480 206,490 207,500
X208,510 209,520 210,530 212,540 213,550
X214,560 215,570 216,580 217,590 218,600
X219,610 220,620 222,630 223,640 224,650
X225,660 226,670 227,680 228,690 229,700
X230,710 231,720 232,730 233,740 234,750
X235,760 236,770 237,780 238,790 239,810
X240,820 241,830 242,840 243,850 244,860
X245,870 246,880 247,890 248,900 249,920
X250,930 251,940 252,950 253,960 254,970
X255,990
X#-This-is-the-Chfeed
X0  63  89  108 125
X140 153 166 177 188
X198 208 217 226 234
X243 250 258 266 273
X280 287 294 300 307
X313 319 325 331 337
X343 349 354 360 365
X370 376 381 386 391
X396 401 406 411 415
X420 425 429 434 438
X443 447 452 456 460
X464 469 473 477 481
X485 489 493 497 501
X505 509 513 516 520
X524 528 531 535 539
X542 546 550 553 557
X560 564 567 571 574
X577 581 584 587 591
X594 597 601 604 607
X610 614 617 620 623
X626 629 632 636 639
X642 645 648 651 654
X657 660 663 666 669
X672 674 677 680 683
X686 689 692 695 697
X700 703 706 708 711
X714 717 719 722 725
X728 730 733 736 738
X741 744 746 749 751
X754 757 759 762 764
X767 770 772 775 777
X780 782 785 787 790
X792 795 797 800 802
X804 807 809 812 814
X816 819 821 824 826
X828 831 833 835 838
X840 842 845 847 849
X852 854 856 859 861
X863 865 868 870 872
X874 877 879 881 883
X886 888 890 892 894
X897 899 901 903 905
X907 910 912 914 916
X918 920 922 925 927
X929 931 933 935 937
X939 941 944 946 948
X950 952 954 956 958
X960 962 964 966 968
X970 972 974 976 978
X980 982 984 986 988
X990 992 994 996 998
X1000
X#-this-is-the-Revtime
X0,1 3,2 7,3 11,4 15,5 19,6
X23,7 27,8 31,9 35,10 39,11
X43,12 46,13 49,14 52,15 55,16
X58,17 61,18 64,19 67,20 70,21
X73,22 75,23 78,24 80,25 83,26
X85,27 87,28 89,29 91,30 93,31
X95,32 97,33 98,34 100,35 102,36
X103,37 105,38 107,39 108,40 109,41
X111,42 112,43 114,44 115,45 116,46
X117,47 119,48 120,49 121,50 122,51
X123,52 124,53 125,54 126,55 127,56
X128,57 129,58 130,59 131,60 132,61
X133,62 134,63 135,65 136,66 137,67
X138,68 139,70 140,71 141,72 142,74
X143,75 144,77 145,78 146,80 147,81
X148,83 149,85 150,86 151,88 152,90
X153,92 154,94 155,95 156,97 157,99
X158,100 160,110 165,120 168,130 172,140
X175,150 178,160 181,170 184,180 186,190
X189,200 191,210 193,220 195,230 197,240
X199,250 200,260 202,270 204,280 205,290
X206,300 208,310 209,320 211,330 212,340
X213,350 214,360 215,370 216,380 218,390
X219,400 220,410 221,420 222,430 223,450
X224,460 225,470 226,480 227,490 228,500
X229,520 230,530 231,540 232,560 233,570
X234,590 235,600 236,620 237,630 238,650
X239,660 240,680 241,700 242,720 243,740
X244,750 245,770 246,790 247,810 248,840
X249,860 250,880 251,900 252,920 253,950
X254,970 255,990
X#-This-is-the-Dtime
X0 0 1 1 1 2 2 3 3 4
X5 6 6 7 8 9 10 12 13 14
X15 17 18 20 21 23 25 26 28 30
X32 34 36 38 40 43 45 47 50 52
X55 57 60 63 65 68 71 74 77 80
X83 86 90 93 96 100 103 107 111 114
X118 122 126 130 134 138 142 146 150 154
X159 163 168 172 177 181 186 191 196 201
X206 211 216 221 226 231 236 242 247 253
X258 264 270 275 281 287 293 299 305 311
X317 323 330 336 342 349 355 362 369 375
X382 389 396 403 410 417 424 431 438 446
X453 460 468 475 483 491 498 506 514 522
X530 538 546 554 562 571 579 587 596 604
X613 621 630 639 648 657 665 674 684 693
X702 711 720 730 739 749 758 768 777 787
X797 807 817 827 837 847 857 867 877 888
X898 908 919 929 940 951 961 972 983 994
X1000 1010 1020 1030 1050 1060 1070 1080 1090 1100
X1110 1130 1140 1150 1160 1170 1180 1200 1210 1220
X1230 1250 1260 1270 1280 1290 1310 1320 1330 1350
X1360 1370 1380 1400 1410 1420 1440 1450 1460 1480
X1490 1500 1520 1530 1540 1560 1570 1580 1600 1610
X1630 1640 1650 1670 1680 1700 1710 1730 1740 1760
X1770 1780 1800 1810 1830 1840 1860 1870 1890 1900
X1920 1930 1950 1960 1980 2000
X#-This-is-the-Predly
X0 0 0 0 0 0 0 0 0 1
X1 1 1 1 2 2 2 2 2 3
X3 3 4 4 4 5 5 6 6 6
X7 7 8 8 9 9 10 11 11 12
X12 13 14 14 15 16 16 17 18 18
X19 20 21 22 22 23 24 25 26 27
X28 29 30 31 31 32 33 35 36 37
X38 39 40 41 42 43 44 46 47 48
X49 50 52 53 54 56 57 58 60 61
X62 64 65 67 68 69 71 72 74 75
X77 78 80 82 83 85 86 88 90 91
X93 95 96 98 100 102 103 105 107 109
X111 113 114 116 118 120 122 124 126 128
X130 132 134 136 138 140 142 144 146 149
X151 153 155 157 159 162 164 166 168 171
X173 175 178 180 182 185 187 190 192 194
X197 199 202 204 207 209 212 214 217 220
X222 225 227 230 233 235 238 241 244 246
X249 252 255 258 260 263 266 269 272 275
X278 281 283 286 289 292 295 298 301 305
X308 311 314 317 320 323 326 329 333 336
X339 342 346 349 352 355 359 362 365 369
X372 376 379 382 386 389 393 396 400 403
X407 410 414 417 421 425 428 432 436 439
X443 447 450 454 458 462 465 469 473 477
X481 484 488 492 496 500
X#-This-is-the-end
END_OF_FILE
if test 9806 -ne `wc -c <'glibinit.dp5'`; then
    echo shar: \"'glibinit.dp5'\" unpacked with wrong size!
fi
# end of 'glibinit.dp5'
fi
if test -f 'list.c' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'list.c'\"
else
echo shar: Extracting \"'list.c'\" \(8986 characters\)
sed "s/^X//" >'list.c' <<'END_OF_FILE'
X/* $Id: list.c,v 1.6 89/05/06 17:13:31 lee Exp $
X * GLIB - a Generic LIBrarian and editor for synths
X * Tim Thompson
X * modified by everyone
X *
X * The E array is the list of synths that can be handled.
X * GLIB is completely driven from the stuff in the editinfo structure.
X * To add/delete a synth, just add/delete an entry to the E array,
X * and provide the functions.  The #defines at the top provide a
X * convenient way of including/excluding synths that are already
X * supported.
X * $Log:    list.c,v $
X * Revision 1.6  89/05/06  17:13:31  lee
X * rel. to comp.sources.misc
X *
X */
X
X#ifdef KAWAIK1
X#define K1multi
X#define K1single
X#define PATDATAID 0xf1
X#define TONDATAID 0xf3
X#endif
X
X#ifdef ROLANDD10
X#define D10pat
X#define D10tim
X#define D10wfg
X#define D10tvf
X#define D10tva
X#define D10rsu
X#define D10urp
X#define D10tra
X#define PATDATAID 0xf1
X#define TIMDATAID 0xf2
X#define TONDATAID 0xf3
X#define RSUDATAID 0xf4
X#define URPDATAID 0xf5
X#define TRADATAID 0xf6
X#endif
X
X#include "glib.h"
X
X#ifdef DX100
Xextern dxtxdin(), dxtxdout(), dx1snof(), dx1sbulk(), dx1gbulk(), dx1sedit();
Xextern char *dx1nof();
Xextern struct paraminfo Pdx100[];
Xextern struct labelinfo Ldx100[];
X#endif
X
X#ifdef TX81Z
Xextern dxtxdin(), dxtxdout(), dx1snof(), dx1sbulk(), dx1gbulk(), dx1sedit();
Xextern char *dx1nof();
Xextern struct paraminfo Ptx81z[];
Xextern struct labelinfo Ltx81z[];
X#endif
X
X#ifdef TX81ZPERF
Xextern tx8pdin(), tx8pdout(), tx8psedit(), tx8psbulk(), tx8pgbulk(), tx8psnof();
Xextern char *tx8pnof();
Xextern struct paraminfo Ptx81p[];
Xextern struct labelinfo Ltx81p[];
X#endif
X
X#ifdef DEP5
Xextern struct paraminfo Pdep5[];
Xextern struct labelinfo Ldep5[];
Xextern dep5din(), dep5dout(), dep5snof(), dep5sone(), dep5sedit();
Xextern char *dep5nof();
X#endif
X
X#ifdef DW8000
Xextern struct paraminfo Pdw800[];
Xextern struct labelinfo Ldw800[];
Xextern dw8din(), dw8dout(), dw8snof(), dw8sone(), dw8gbulk();
Xextern dw8numv(), dw8sedit();
Xextern char *dw8nof(), *dw8vnum();
X#endif
X
X#ifdef KAWAIK5
Xextern struct paraminfo Pk5s[], Pk5m[];
Xextern struct labelinfo Lk5s[], Lk5m[];
Xextern k5sdin(), k5sdout(), k5ssnof(), k5ssone();
Xextern k5mdin(), k5mdout(), k5msnof(), k5msone();
Xextern k5ssbulk(), k5msbulk();
Xextern k5numv(), k5ssedit(), k5msedit(), k5sgbulk(), k5mgbulk();
Xextern char *k5snof(), *k5mnof(), *k5vnum();
X#endif
X
X#ifdef D10pat
Xextern struct paraminfo Pdpat[];
Xextern struct labelinfo Ldpat[];
Xextern dpatdin(), dpatdout(), dpatsnof(), dpatsone(), dpatgbulk();
Xextern dnumpat(), dpatsedit(), dpatsbulk();
Xextern char *dpatnof(), *dpatnum();
X#endif
X
X#ifdef D10tim
Xextern struct paraminfo Pdtim[];
Xextern struct labelinfo Ldtim[];
Xextern dtimdin(), dtimdout(), dtimsnof(), dtimsone(), dtimgbulk();
Xextern dnumtim(), dtimsedit(), dtimsbulk();
Xextern char *dtimnof(), *dtimnum();
X#endif
X
X#ifdef D10wfg
Xextern struct paraminfo Pdwfg[];
Xextern struct labelinfo Ldwfg[];
Xextern dwfgdin(), dwfgdout(), dtonsnof(), dtonsone(), dtongbulk();
Xextern dnumton(), dtonsedit(), dtonsbulk();
Xextern char *dtonnof(), *dtonnum();
X#endif
X
X#ifdef D10tvf
Xextern struct paraminfo Pdtvf[];
Xextern struct labelinfo Ldtvf[];
Xextern dtvfdin(), dtvfdout(), dtonsnof(), dtonsone(), dtongbulk();
Xextern dnumton(), dtonsedit(), dtonsbulk();
Xextern char *dtonnof(), *dtonnum();
X#endif
X
X#ifdef D10tva
Xextern struct paraminfo Pdtva[];
Xextern struct labelinfo Ldtva[];
Xextern dtvadin(), dtvadout(), dtonsnof(), dtonsone(), dtongbulk();
Xextern dnumton(), dtonsedit(), dtonsbulk();
Xextern char *dtonnof(), *dtonnum();
X#endif
X
X#ifdef D10rsu
Xextern struct paraminfo Pdrsu[];
Xextern struct labelinfo Ldrsu[];
Xextern drsudin(), drsudout(), drsusnof(), drsusone(), drsugbulk();
Xextern dnumrsu(), drsusedit(), drsusbulk();
Xextern char *drsunof(), *drsunum();
X#endif
X
X#ifdef D10urp
Xextern struct paraminfo Pdurp[];
Xextern struct labelinfo Ldurp[];
Xextern durpdin(), durpdout(), durpsnof(), durpsone(), durpgbulk();
Xextern dnumurp(), durpsedit(), durpsbulk();
Xextern char *durpnof(), *durpnum();
X#endif
X
X#ifdef D10tra
Xextern struct paraminfo Pdtra[];
Xextern struct labelinfo Ldtra[];
Xextern dtradin(), dtradout(), dtrasnof(), dtrasone(), dtragbulk();
Xextern dnumtra(), dtrasedit(), dtrasbulk();
Xextern char *dtranof(), *dtranum();
X#endif
X
X#ifdef K1multi
Xextern struct paraminfo Pk1m[];
Xextern struct labelinfo Lk1m[];
Xextern k1mdin(), k1mdout(), k1msnof(), k1msone(), k1mgbulk();
Xextern k1nummlt(), k1msedit(), k1msbulk();
Xextern char *k1mnof(), *k1mnum();
X#endif
X
X#ifdef K1single
Xextern struct paraminfo Pk1sng[];
Xextern struct labelinfo Lk1sng[];
Xextern k1sdin(), k1sdout();
X#ifndef K1multi
Xextern k1msnof(), k1msone(), k1mgbulk();
Xextern k1nummlt(), k1msedit(), k1msbulk();
Xextern char *k1mnof(), *k1mnum();
X#endif
X#endif
X
X#ifdef DX7
Xextern struct paraminfo Pdx7[];
Xextern struct labelinfo Ldx7[];
Xextern dx7din(), dx7dout(), dx7snof(), dx7sedit(), dx7sbulk(), dx7gbulk();
Xextern char *dx7nof();
X#endif
X
X#ifdef DX7S
Xextern struct paraminfo Pdx7S[];
Xextern struct labelinfo Ldx7S[];
Xextern dx7Sdin(), dx7Sdout(), dx7snof(), dx7Ssedit(), dx7Ssbulk(), dx7Sgbulk();
Xextern char *dx7nof();
X
X/* if the DX7s dataID is changed, it must be changed in readall() as well. */
X
X#define DX7S_DATAID 0xd7
X#endif
X
X#ifdef CZ1
Xextern cz1din(), cz1dout(), cz1snof(), cz1sbulk(), cz1gbulk(),
X       cz1sedit(), cz1sone();
Xextern char *cz1nof();
Xextern struct paraminfo Pcz1[];
Xextern struct labelinfo Lcz1[];
X#endif
X
X
Xstruct editinfo E[] = {
X
X#ifdef DX100
X   {"DX-100", Pdx100, Ldx100, 24, 128, 17, 0xdd,
X    dxtxdin, dxtxdout, dx1sedit, NULL, dx1sbulk, dx1gbulk, dx1nof, dx1snof,
X    NULL, NULL, NULL},
X#endif
X#ifdef DEP5
X   {"DEP-5", Pdep5, Ldep5, 99, 42, 16, 0xdd,
X    dep5din, dep5dout, dep5sedit, dep5sone, NULL, NULL, dep5nof, dep5snof,
X    NULL, NULL, NULL},
X#endif
X#ifdef TX81Z
X   {"TX81Z", Ptx81z, Ltx81z, 32, 128, 17, 0xdd,
X    dxtxdin, dxtxdout, dx1sedit, NULL, dx1sbulk, dx1gbulk, dx1nof, dx1snof,
X    NULL, NULL, NULL},
X#endif
X#ifdef TX81ZPERF
X   {"TX81Z Performance", Ptx81p, Ltx81p, 24, 76, 17, 0xdd,
X    tx8pdin, tx8pdout, tx8psedit, NULL, tx8psbulk, tx8pgbulk, tx8pnof,
X    tx8psnof, NULL, NULL, NULL},
X#endif
X#ifdef DW8000
X   {"DW8000", Pdw800, Ldw800, 64, 72, 17, 0xdd,
X    dw8din, dw8dout, dw8sedit, dw8sone, NULL, dw8gbulk, dw8nof, dw8snof,
X    dw8vnum, dw8numv, NULL},
X#endif
X#ifdef KAWAIK5
X   {"K-5 Single", Pk5s, Lk5s, 48, 984, 8, 0xdd,
X    k5sdin, k5sdout, k5ssedit, k5ssone, k5ssbulk, k5sgbulk,
X    k5snof, k5ssnof, k5vnum, NULL, k5numv},
X   {"K-5 Multi", Pk5m, Lk5m, 48, 352, 8, 0xdd,
X    k5mdin, k5mdout, k5msedit, k5msone, k5msbulk, k5mgbulk,
X    k5mnof, k5msnof, k5vnum, NULL, k5numv},
X#endif
X#ifdef D10pat
X   {"Patches ", Pdpat, Ldpat, 128, 58, 16, PATDATAID,
X    dpatdin, dpatdout, dpatsedit, dpatsone, dpatsbulk,
X    dpatgbulk, dpatnof, dpatsnof, dpatnum, dnumpat, NULL},
X#endif
X
X#ifdef D10tim
X   {"Timbres ", Pdtim, Ldtim, 128, 28, 1, TIMDATAID,
X    dtimdin, dtimdout, dtimsedit, dtimsone, dtimsbulk,
X    dtimgbulk, dtimnof, dtimsnof, dtimnum, dnumtim, NULL},
X#endif
X
X#ifdef D10wfg
X   {"Tone WFG's", Pdwfg, Ldwfg, 64, 266, 10, TONDATAID,
X    dwfgdin, dwfgdout, dtonsedit, dtonsone, dtonsbulk,
X    dtongbulk, dtonnof, dtonsnof, dtonnum, dnumton, NULL},
X#endif
X
X#ifdef D10tvf
X   {"Tone TVF's", Pdtvf, Ldtvf, 64, 266, 10, TONDATAID,
X    dtvfdin, dtvfdout, dtonsedit, dtonsone, dtonsbulk,
X    dtongbulk, dtonnof, dtonsnof, dtonnum, dnumton, NULL},
X#endif
X
X#ifdef D10tva
X   {"Tone TVA's ", Pdtva, Ldtva, 64, 266, 10, TONDATAID,
X    dtvadin, dtvadout, dtonsedit, dtonsone, dtonsbulk,
X    dtongbulk, dtonnof, dtonsnof, dtonnum, dnumton, NULL},
X#endif
X
X#ifdef D10rsu
X   {"Rhythm Setup ", Pdrsu, Ldrsu, 85, 24, 1, RSUDATAID,
X    drsudin, drsudout, drsusedit, drsusone, drsusbulk,
X    drsugbulk, drsunof, drsusnof, drsunum, dnumrsu, NULL},
X#endif
X
X#ifdef D10urp
X   {"Rhythm Patterns ", Pdurp, Ldurp, 32, 608, 1, URPDATAID,
X    durpdin, durpdout, durpsedit, durpsone, durpsbulk,
X    durpgbulk, durpnof, durpsnof, durpnum, dnumurp, NULL},
X#endif
X
X#ifdef D10tra
X   {"Rhythm Track ", Pdtra, Ldtra, 1, 522, 1, TRADATAID,
X    dtradin, dtradout, dtrasedit, dtrasone, dtrasbulk,
X    dtragbulk, dtranof, dtrasnof, dtranum, dnumtra, NULL},
X#endif
X
X#ifdef K1multi
X   {"Multi Patches", Pk1m, Lk1m, 32, 75, 10, PATDATAID,
X    k1mdin, k1mdout, k1msedit, k1msone, k1msbulk,
X    k1mgbulk, k1mnof, k1msnof, k1mnum, NULL, k1nummlt},
X#endif
X
X#ifdef K1single
X   {"Single Patches", Pk1sng, Lk1sng, 64, 87, 10, TONDATAID,
X    k1sdin, k1sdout, k1msedit, k1msone, k1msbulk,
X    k1mgbulk, k1mnof, k1msnof, k1mnum, NULL, k1nummlt},
X#endif
X
X#ifdef DX7
X   {"DX7", Pdx7, Ldx7, 32, 128, 10, 0,
X    dx7din, dx7dout, dx7sedit, NULL, dx7sbulk, dx7gbulk, dx7nof, dx7snof,
X    NULL, NULL, NULL},
X#endif
X#ifdef DX7S
X   {"DX7s", Pdx7S, Ldx7S, 32, 163, 10, DX7S_DATAID,
X    dx7Sdin, dx7Sdout, dx7Ssedit, NULL, dx7Ssbulk, dx7Sgbulk, dx7nof,
X        dx7snof,
X    NULL, NULL, NULL},
X#endif
X
X#ifdef CZ1
X   {"CZ1", Pcz1, Lcz1, 64, 144, 16, 0xdd,
X    cz1din, cz1dout, cz1sedit, cz1sone, NULL, cz1gbulk, cz1nof, cz1snof,
X /* cz1sbulk() is defined, but we use cz1sone(). */
X    NULL, NULL, NULL},
X#endif
X
X
X   {NULL,NULL,NULL,0,0,0,0,
X    NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL}
X};
END_OF_FILE
if test 8986 -ne `wc -c <'list.c'`; then
    echo shar: \"'list.c'\" unpacked with wrong size!
fi
# end of 'list.c'
fi
echo shar: End of archive 4 \(of 15\).
cp /dev/null ark4isdone
MISSING=""
for I in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 ; do
    if test ! -f ark${I}isdone ; then
    MISSING="${MISSING} ${I}"
    fi
done
if test "${MISSING}" = "" ; then
    echo You have unpacked all 15 archives.
    rm -f ark[1-9]isdone ark[1-9][0-9]isdone
else
    echo You still need to unpack the following archives:
    echo "        " ${MISSING}
fi
##  End of shell archive.
exit 0